package net.cyue.web.easyquery.core.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.tomlj.Toml;
import org.tomlj.TomlArray;
import org.tomlj.TomlParseResult;
import org.tomlj.TomlTable;

import java.math.BigInteger;
import java.util.Optional;

public class TOMLUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(TOMLUtil.class);

    public static TomlParseResult parse(String toml) {
        return Toml.parse(toml);
    }

    public static String toJSON(String toml) {
        return Toml.parse(toml).toJson();
    }


    /**
     * 获取指定路径的嵌套表格
     * 支持点符号表示法，如"parent.child.grandchild"
     * @param rootTable 根表格
     * @param tablePath 表格路径
     * @return 嵌套表格，如果不存在则返回空Toml对象
     */
    public static Optional<TomlTable> getTable(TomlTable rootTable, String tablePath) {
        if (rootTable == null || tablePath == null || tablePath.isEmpty()) {
            return Optional.empty();
        }

        TomlTable currentTable = rootTable;
        String[] pathSegments = tablePath.split("\\.");

        for (String segment : pathSegments) {
            TomlTable nextTable = currentTable.getTable(segment);
            if (nextTable == null) {
                return Optional.empty();
            }
            currentTable = nextTable;
        }

        return Optional.of(currentTable);
    }

    /**
     * 获取指定路径的字符串值
     * @param table Toml表格
     * @param path 字段路径
     * @return 字符串值，如果不存在则返回null
     */
    public static String getString(TomlTable table, String path) {
        return getString(table, path, null);
    }

    /**
     * 获取指定路径的字符串值，支持默认值
     * @param table Toml表格
     * @param path 字段路径
     * @param defaultValue 默认值
     * @return 字符串值或默认值
     */
    public static String getString(TomlTable table, String path, String defaultValue) {
        return Optional.ofNullable(table.getString(path)).orElse(defaultValue);
    }

    /**
     * 获取指定路径的long值
     * @param table Toml表格
     * @param path 字段路径
     * @return long值，如果不存在或无效则返回0L
     */
    public static long getLong(TomlTable table, String path) {
        return getLong(table, path, 0L);
    }

    /**
     * 获取指定路径的long值，支持默认值
     * @param table Toml表格
     * @param path 字段路径
     * @param defaultValue 默认值
     * @return long值或默认值
     */
    public static Long getLong(TomlTable table, String path, Long defaultValue) {
        return Optional.ofNullable(table.getLong(path)).orElse(defaultValue);
    }

    /**
     * 获取指定路径的double值
     * @param table Toml表格
     * @param path 字段路径
     * @return double值，如果不存在或无效则返回0.0
     */
    public static double getDouble(TomlTable table, String path) {
        return getDouble(table, path, 0.0);
    }

    /**
     * 获取指定路径的double值，支持默认值
     * @param table Toml表格
     * @param path 字段路径
     * @param defaultValue 默认值
     * @return double值或默认值
     */
    public static Double getDouble(TomlTable table, String path, Double defaultValue) {
        return Optional.ofNullable(table.getDouble(path)).orElse(defaultValue);
    }


    /**
     * 获取指定路径的boolean值
     * @param table Toml表格
     * @param path 字段路径
     * @return boolean值，如果不存在或无效则返回false
     */
    public static boolean getBoolean(TomlTable table, String path) {
        return getBoolean(table, path, false);
    }

    /**
     * 获取指定路径的boolean值，支持默认值
     * @param table Toml表格
     * @param path 字段路径
     * @param defaultValue 默认值
     * @return boolean值或默认值
     */
    public static Boolean getBoolean(TomlTable table, String path, Boolean defaultValue) {
        return Optional.ofNullable(table.getBoolean(path)).orElse(defaultValue);
    }

    /**
     * 获取表格数组（[[table.array]]形式）
     * @param parentTable 父表格
     * @param arrayKey 数组键名
     * @return 表格数组，如果不存在则返回空列表
     */
    public static TomlArray getArray(TomlTable parentTable, String arrayKey) {
        return getArray(parentTable, arrayKey, null);
    }


    /**
     * 获取表格数组（[[table.array]]形式）
     * @param parentTable 父表格
     * @param arrayKey 数组键名
     * @param defaultValue 默认值
     * @return 表格数组，如果不存在则返回空列表
     */
    public static TomlArray getArray(TomlTable parentTable, String arrayKey, TomlArray defaultValue) {
        return Optional.ofNullable(parentTable.getArray(arrayKey)).orElse(defaultValue);
    }


    /**
     * 从表格中获取指定类型的值
     * @param table 表格
     * @param key 键名
     * @param clazz 目标类型
     * @param <T> 目标类型
     * @return 转换后的值，如果无法转换则返回null
     */
    @SuppressWarnings("unchecked")
    public static <T> T getValueFromTable(TomlTable table, String key, Class<T> clazz) {
        if (clazz == String.class) {
            return (T) getString(table, key);
        } else if (clazz == Integer.class) {
            return (T) getLong(table, key, null);
        } else if (clazz == Long.class) {
            return (T) getLong(table, key, null);
        } else if (clazz == Float.class) {
            return (T) getDouble(table, key, null);
        } else if (clazz == Double.class) {
            return (T) getDouble(table, key, null);
        } else if (clazz == Boolean.class) {
            return (T) getBoolean(table, key, null);
        } else if (clazz == Toml.class) {
            return (T) table.getTable(key);
        } else {
            LOGGER.warn("Unsupported type: {}", clazz.getName());
            return null;
        }
    }

    /**
     * 检查表格是否包含指定键
     * @param table 表格
     * @param key 键名
     * @return 如果包含则返回true，否则返回false
     */
    public static boolean hasKey(TomlTable table, String key) {
        return table.contains(key);
    }
}
